local s = "hello word"

print("lua: " .. s)


-- Lua简介
-- ┌───────────────────────────────────────────────────────────────────────────────────────────────────┐
-- │ Lua是一个小巧的脚本语言。是巴西里约热内卢天主教大学（Pontifical Catholic University of Rio de             │
-- │ Janeiro）里的一个研究小组，由Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de                 │
-- │ Figueiredo所组成并于1993年开发。                                                                     │
-- │ 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。                                      │
-- │ Lua由标准C编写而成，几乎在所有操作系统和平台上都可以编译，运行。                                            │
-- │ Lua并没有提供强大的库，这是由它的定位决定的。所以Lua不适合作为开发独立应用程序的语言。                          │
-- │ Lua 有一个同时进行的JIT项目，提供在特定平台上的即时编译功能。                                               │
-- │ Lua脚本可以很容易的被C/C++                                                                           │
-- │ 代码调用，也可以反过来调用C/C++的函数，这使得Lua在应用程序中可以被广泛应用。                                  │
-- │ 不仅仅作为扩展脚本，也可以作为普通的配置文件，代替XML,ini等文件格式，并且更容易理解和维护。                      │
-- │ Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。                                 │
-- │ 一个完整的Lua解释器不过200k，在目前所有脚本引擎中，Lua的速度是最快的。这一切都决定了Lua是作为嵌入式脚本的最佳选择。 │
-- │ **lua的目标：**其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。                         │
-- └───────────────────────────────────────────────────────────────────────────────────────────────────┘

-- Lua 应用场景：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ 游戏开发                                                                       │
-- │ 独立应用脚本                                                                   │
-- │ Web 应用脚本                                                                   │
-- │ 扩展和数据库插件如：MySQL Proxy 和 MySQL WorkBench                               │
-- │ 安全系统，如入侵检测系统                                                         │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- First Lua Program
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ print("Hello World!")                                                        │
-- │ print "HelloWorld"                                                           │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- Lua基本语法
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ lua语法格式没有高级语言这么严格，好比说每句代码末尾的分号可加可不加                     │
-- │ lua中不需要用类型来声明对象                                                      │
-- └──────────────────────────────────────────────────────────────────────────────┘
-- 脚本式编程：  我们可以将 Lua 程序代码保持到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程

-- 注释：
--当行注释
--[[
多行注释
]]--


-- 全局变量：
-- 在默认情况下，变量总是认为是全局的。
-- 全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ a = 10                                                                       │
-- │ print(a)                                                                     │
-- │ print(b)                                                                     │
-- │                                                                              │
-- │ --如果你想删除一个全局变量，只需要将变量赋值为nil                                    │
-- │ a = nil                                                                      │
-- │ print(a)                                                                     │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- Lua数据类型
-- Lua中有8中数据类型，分别是：
    -- nil、boolean、number、string、function、userdata（用户自定义类型）、thread、table。


--基本使用
-- do  --看这里
-- function hello_world(args1, args2)
--     print (args1, args2)
-- end

-- hello_world("hello", "world")


-- 测试：
print(type(nil))   --nil
print(type(true))  --boolean
print(type("cch")) --string
print(type(3.3))   --number
print(type({}))    --table
print(type(print)) --function、

-- 遍历一个table：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ tab1 = {name = "cch",age = 22}                                               │
-- │ print(tab1.name)                                                             │
-- │ for key,value in pairs(tab1) do                                              │
-- │     print(key..":"..value)                                                   │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- nil在条件判断中代表false：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ b = nil                                                                      │
-- │ if(b) then                                                                   │
-- │     print(true)                                                              │
-- │ else                                                                         │
-- │     print(false)                                                             │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ Lua 变量有三种类型：全局变量、局部变量、表中的域。                                   │
-- │ Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。      │
-- │ 局部变量的作用域为从声明位置开始到所在语句块结束。                                   │
-- │ 变量的默认值均为 nil。                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- 赋值语句：
-- 赋值是改变一个变量的值和改变表域的最基本的方法。
-- Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ a,b,c = 10,4,5                                                               │
-- │ print(a)                                                                     │
-- │ print(b)                                                                     │
-- │ print(c                                                                      │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 索引：
-- 对 table 的索引使用方括号 []。Lua 也提供了 . 操作。
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ tab1 = {name = "cch",age = 22}                                               │
-- │ print(tab1["name"]) --cch                                                    │
-- │ print(tab1.name)   --cch                                                     │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- 循环
-- Lua中提供了三种循环方式：
    -- while、for、repeat…until

-- while:
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ while(condition)                                                             │
-- │ do                                                                           │
-- │    statements                                                                │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- while循环测试：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ a = 20                                                                       │
-- │ while(a > 0) do                                                              │
-- │     print(a)                                                                 │
-- │     a = a - 1                                                                │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- for:
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ for var=exp1,exp2,exp3 do                                                    │
-- │     <执行体>                                                                  │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘ 

-- var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3是可选的，如果不指定，默认为1。
-- for循环测试：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ for i = 10,1,-1 do                                                           │
-- │     print(i)                                                                 │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- repeat…until：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ repeat                                                                       │
-- │    statements                                                                │
-- │ until( condition )                                                           │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 当until后面的条件语句为true时停止执行循环体，次循环的循环体至少执行一次
-- repeat…until循环测试：

-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ a = 10                                                                       │
-- │ repeat                                                                       │
-- │     print(a)                                                                 │
-- │     a = a - 1                                                                │
-- │ until(a <= 0)                                                                │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- 循环嵌套（打印九九乘法表）：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ for i = 1,9,1 do                                                             │
-- │     local str = "";                                                          │
-- │     for j = 1,i,1 do                                                         │
-- │         str = str .."\t".. j.."*"..i.."="..(i*j)                             │
-- │     end                                                                      │
-- │     print(str)                                                               │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ 1*1=1                                                                        │
-- │ 1*2=2	2*2=4                                                                 │
-- │ 1*3=3	2*3=6	3*3=9                                                         │
-- │ 1*4=4	2*4=8	3*4=12	4*4=16                                                │
-- │ 1*5=5	2*5=10	3*5=15	4*5=20	5*5=25                                        │
-- │ 1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36                                │
-- │ 1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49                        │
-- │ 1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64                │
-- │ 1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81        │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 流程控制语句
-- Lua中只提供了if…else的流程控制语句，没有c#中的switch语句
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ if(条件)                                                                      │
-- │ then                                                                         │
-- │     代码块                                                                    │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 函数（function）
-- 函数的定义：
-- ┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
-- │ optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)   │
-- │     function_body                                                                                │
-- │     return result_params_comma_separated                                                         │
-- │ end                                                                                              │
-- └──────────────────────────────────────────────────────────────────────────────────────────────────┘

-- ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
-- │ optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。│
-- │ function_name: 指定函数名称。                                                                                          │
-- │ argument1, argument2, argument3…, argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。                              │
-- │ function_body: 函数体，函数中需要执行的代码语句块。                                                                        │
-- │ result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。                                      │
-- │                                                                                                                      │
-- └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

-- 实例：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ function Max(num1,num2)                                                      │
-- │     local maxNum                                                             │
-- │     if(num1 > num2) then                                                     │
-- │         maxNum = num1                                                        │
-- │     else                                                                     │
-- │         maxNum = num2                                                        │
-- │     end                                                                      │
-- │     return maxNum                                                            │
-- │ end                                                                          │
-- │ print(Max(2,3))                                                              │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- 函数多返回值：
-- Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ function MaxAndMin(...)                                                      │
-- │     local tab = {...}                                                        │
-- │     local max = tab[1]                                                       │
-- │     local min = tab[1]                                                       │
-- │     for key,value in pairs(tab) do                                           │
-- │         if(value > max) then                                                 │
-- │             max = value;                                                     │
-- │         end                                                                  │
-- │         if(value < min) then                                                 │
-- │             min = value;                                                     │
-- │         end                                                                  │
-- │     end                                                                      │
-- │     return min,max                                                           │
-- │ end                                                                          │
-- │ print(MaxAndMin(0,8,2,3,45))   --0 45                                        │
-- │ print(string.find("cchcch",'cch')) -- 1 3                                    │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 可变参数
-- Lua 函数可以接受可变数目的参数，类似于c#中的params，在函数参数列表中使用三点 … 表示函数有可变的参数。
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ function Add(...)                                                            │
-- │     local tab = {...}                                                        │
-- │     local sum = 0                                                            │
-- │     for key,value in pairs(tab) do                                           │
-- │         sum = sum + value;                                                   │
-- │     end                                                                      │
-- │     return sum,#tab                                                          │
-- │ end                                                                          │
-- │                                                                              │
-- │ print(Add(12,13,56))  --81 3                                                 │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- 运算符 - 自查
-- 运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua提供了以下几种运算符类型：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ 算术运算符                                                                     │
-- │ 关系运算符                                                                     │
-- │ 逻辑运算符                                                                     │
-- │ 其他运算符                                                                     │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- 实例：Lua实现快速排序
-- ┌─────────────────────────────────────────────────────────────────────────────────────────┐
-- │ function QuickSortUnit(tab,left,right)                                                  │
-- │     local temp = tab[left]                                                              │
-- │     while(left < right) do                                                              │
-- │         while(left < right and temp < tab[right]) do                                    │
-- │             right = right - 1;                                                          │
-- │         end                                                                             │
-- │         tab[left] = tab[right]                                                          │
-- │         while(left < right and temp >= tab[left]) do                                    │
-- │             left = left + 1                                                             │
-- │         end                                                                             │
-- │         tab[right] = tab[left]                                                          │
-- │     end                                                                                 │
-- │     tab[left] = temp                                                                    │
-- │     return left                                                                         │
-- │ end                                                                                     │
-- │                                                                                         │
-- │ function QuickSort(tab,left,right)                                                      │
-- │     local index = QuickSortUnit(tab,left,right)                                         │
-- │     if(left < right) then                                                               │
-- │         QuickSort(tab,left,index-1)                                                     │
-- │         QuickSort(tab,index+1,right)                                                    │
-- │     end                                                                                 │
-- │ end                                                                                     │
-- │                                                                                         │
-- │ tab1 = {45,32,23,16,9}                                                                  │
-- │ QuickSort(tab1,1,#tab1)                                                                 │
-- │ for key,value in pairs(tab1) do                                                         │
-- └─────────────────────────────────────────────────────────────────────────────────────────┘

-- 字符串
-- 常用的一些函数：
-- ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
-- │ string.upper(argument)                                                                                               │
-- │ string.lower(argument)                                                                                               │
-- │ string.gsub(mainString,findString,replaceString,num)                                                                 │
-- │ 在字符串中替换,mainString为要替换的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换）│
-- │ string.find (str, substr, [init, [end]])                                                                             │
-- │ 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。                                         │
-- │ string.reverse(arg)                                                                                                  │
-- │ string.format(…)                                                                                                     │
-- │ string.char(arg) 和 string.byte(arg[,int])                                                                            │
-- │ char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。                                         │
-- │ string.len(arg)                                                                                                      │
-- │ string.rep(string, n)                                                                                                │
-- │ …                                                                                                                    │
-- │ string.gmatch(str, pattern)                                                                                          │
-- │ 回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。                                   │
-- │ 如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。                                                                     │
-- │ string.match(str, pattern, init)                                                                                     │
-- │ string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。                                       │
-- │ 在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。           │
-- └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘


-- 数组与迭代器
-- Lua中的数组与c#不同，Lua中的数组下标从1开始，其他方面差不多
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ tab = {23,3,4,5,56,67}                                                       │
-- │ for i=1,#tab do                                                              │
-- │     print(tab[i])                                                            │
-- │     i = i+1                                                                  │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘
-- 迭代器：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ tab = {23,3,4,5,56,67}                                                       │
-- │ for k,v in pairs(tab) do                                                     │
-- │     print(v)                                                                 │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘


-- Lua table(表)
-- table表的介绍：
-- ┌─────────────────────────────────────────────────────────────────────────────┐
-- │ table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。           │
-- │ Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。      │
-- │ Lua table 是不固定大小的，你可以根据自己需要进行扩容。                              │
-- │ Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。             |
-- | 例如string.format表示使用"format"来索引table string。                           │
-- └─────────────────────────────────────────────────────────────────────────────┘

-- ┌─────────────────────────────────────────────────────────────────────────────┐
-- │ -- table.concat(tab)     表连接  返回连接后的字符串                             │
-- │ tab = {3,4,5,6,7,8}                                                         │
-- │ print(table.concat(tab))        --345678                                    │
-- │ print(table.concat(tab,","))     --3,4,5,6,7,8                              │
-- │ print(table.concat(tab," ",1,3)) --3 4 5                                    │
-- │                                                                             │
-- │ tab1 = {3,4,5,6,7}                                                          │
-- │ table.insert(tab1,5,100);                                                   │
-- │ for key,value in pairs(tab1) do                                             │
-- │     print(key..":"..value)                                                  │
-- │ end                                                                         │
-- │ --1:3                                                                       │
-- │ --2:4                                                                       │
-- │ --3:5                                                                       │
-- │ --4:6                                                                       │
-- │ --5:100                                                                     │
-- │ --6:7                                                                       │
-- │                                                                             │
-- │ --tab = {3,4,5,6,7,8}                                                       │
-- │ table.remove(tab); --默认删除最后一个                                          │
-- │ table.remove(tab,4);                                                        │
-- │ for key,value in pairs(tab) do                                              │
-- │     print(key..":"..value)                                                  │
-- │ end                                                                         │
-- │                                                                             │
-- │ -- table.sort(tab)  排序                                                     │
-- │ tab = {3,4,5,6,7,8}                                                         │
-- │ --table.sort(tab) --升序                                                    │
-- │ table.sort(tab,function(a,b) return (a>b) end)  --降序                      │
-- │                                                                             │
-- │ for key,value in pairs(tab) do                                              │
-- │     print(value)                                                            │
-- │ end                                                                         │
-- └─────────────────────────────────────────────────────────────────────────────┘



-- 自定义迭代器：
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ tab2 = {1,2,3,4}                                                             │
-- │ function fun(tab,index)                                                      │
-- │     index = index+1                                                          │
-- │     local value = tab[index]                                                 │
-- │     if(value) then                                                           │
-- │         return index,value                                                   │
-- │     end                                                                      │
-- │ end                                                                          │
-- │                                                                              │
-- │ function selfpairs(tab)                                                      │
-- │     return fun,tab,0                                                         │
-- │ end                                                                          │
-- │                                                                              │
-- │ for key,value in selfpairs(tab2) do                                          │
-- │     print(key,value)                                                         │
-- │ end                                                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘



-- 协程
-- Lua协程基本语法：
-- coroutine.create(方法) coroutine.resume(方法，参数)
-- 创建协程，和唤醒协程，两个方法搭配起来使用
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ co = coroutine.create(                                                       │
-- │     function(i)                                                              │
-- │         print(i)                                                             │
-- │     end                                                                      │
-- │ )                                                                            │
-- │ coroutine.resume(co,1)  --1                                                  │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- coroutine.wrap(方法)
-- 返回一个函数，一旦调用这个函数，就进入协程

-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ co = coroutine.wrap(                                                         │
-- │     function()                                                               │
-- │         print("协程")                                                         │
-- │     end                                                                      │
-- │ )                                                                            │
-- │ co() --协程                                                                   │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- coroutine.status(co)
-- 获取协程的状态（三种状态：suspended挂起 dead死亡 running运行中）

-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │ co = coroutine.create(                                                       │
-- │     function(i)                                                              │
-- │         print(i)                                                             │
-- │     end                                                                      │
-- │ )                                                                            │
-- │ print(coroutine.status(co)) --suspended                                      │
-- │ coroutine.resume(co,1)       --1                                             │
-- │ print(coroutine.status(co))  --dead                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘

-- coroutine.yield(参数)
-- 挂起协程，和resume()搭配只用，两个函数（或者说协程内部和外部）之间进行调用
-- resume和yield的配合强大之处在于，resume处于主程中，它将外部状态（数据）传入到协同程序内部；而yield则将内部的状态（数据）返回到主程中。
-- ┌──────────────────────────────────────────────────────────────────────────────┐
-- │                                                                              │
-- │ co = coroutine.create(                                                       │
-- │     function(i)                                                              │
-- │         num1,num2 = coroutine.yield(89)                                      │
-- │         print(i,num1,num2) -- 1 2                                            │
-- │     end                                                                      │
-- │ )                                                                            │
-- │ print(coroutine.status(co)) --suspended                                      │
-- │ print(coroutine.resume(co,1))   --true 89                                    │
-- │ coroutine.resume(co,2,3)                                                     │
-- │ print(coroutine.status(co))  --dead                                          │
-- └──────────────────────────────────────────────────────────────────────────────┘